diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index 2242f86..0279e48 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Change Log</title>
+<title>Change Log : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='userguide.css' />
@@ -89,6 +89,7 @@
 	</li>
     <li>Helpers
 		<ul>
+			<li>Added a Compatibility Helper for using some common PHP 5 functions safely in applications that might run on PHP 4 servers</li>
 			<li>Added <kbd>form_button()</kbd> in the <a href="helpers/form_helper.html">Form helper</a>.</li>
 			<li>Changed the radio() and checkbox() functions to default to not checked by default.</li>
 			<li>Added the ability to include an optional HTTP Response Code in the <kbd>redirect()</kbd> function of the <a href="helpers/url_helper.html">URL Helper</a>.</li>
diff --git a/user_guide/database/active_record.html b/user_guide/database/active_record.html
index 68434d3..fa0ed9d 100644
--- a/user_guide/database/active_record.html
+++ b/user_guide/database/active_record.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Active Record</title>
+<title>Active Record : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/caching.html b/user_guide/database/caching.html
index cb11922..52e9ccd 100644
--- a/user_guide/database/caching.html
+++ b/user_guide/database/caching.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Database Caching Class</title>
+<title>Database Caching Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/call_function.html b/user_guide/database/call_function.html
index b99c335..d1eab14 100644
--- a/user_guide/database/call_function.html
+++ b/user_guide/database/call_function.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Custom Function Calls</title>
+<title>Custom Function Calls : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/configuration.html b/user_guide/database/configuration.html
index a6da7e1..6709876 100644
--- a/user_guide/database/configuration.html
+++ b/user_guide/database/configuration.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Database Configuration</title>
+<title>Database Configuration : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/connecting.html b/user_guide/database/connecting.html
index 4a859d1..c1e9560 100644
--- a/user_guide/database/connecting.html
+++ b/user_guide/database/connecting.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Connecting to your Database</title>
+<title>Connecting to your Database : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/examples.html b/user_guide/database/examples.html
index e879289..5fe36aa 100644
--- a/user_guide/database/examples.html
+++ b/user_guide/database/examples.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Database Quick Start</title>
+<title>Database Quick Start : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/fields.html b/user_guide/database/fields.html
index d8a802d..f4a4fd2 100644
--- a/user_guide/database/fields.html
+++ b/user_guide/database/fields.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Field Data</title>
+<title>Field Data : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/forge.html b/user_guide/database/forge.html
index ecb1457..45d643b 100644
--- a/user_guide/database/forge.html
+++ b/user_guide/database/forge.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Database Forge Class</title>
+<title>Database Forge Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/helpers.html b/user_guide/database/helpers.html
index b3dab62..698b3f2 100644
--- a/user_guide/database/helpers.html
+++ b/user_guide/database/helpers.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Query Helper Functions</title>
+<title>Query Helper Functions : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/index.html b/user_guide/database/index.html
index c7ea2d7..326b1ef 100644
--- a/user_guide/database/index.html
+++ b/user_guide/database/index.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : The Database Class</title>
+<title>The Database Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/queries.html b/user_guide/database/queries.html
index e443958..9d85227 100644
--- a/user_guide/database/queries.html
+++ b/user_guide/database/queries.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Queries</title>
+<title>Queries : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/results.html b/user_guide/database/results.html
index 3829147..c2f6693 100644
--- a/user_guide/database/results.html
+++ b/user_guide/database/results.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Generating Query Results</title>
+<title>Generating Query Results : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/table_data.html b/user_guide/database/table_data.html
index 5c4c39b..4d33fb0 100644
--- a/user_guide/database/table_data.html
+++ b/user_guide/database/table_data.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Table Data</title>
+<title>Table Data : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/transactions.html b/user_guide/database/transactions.html
index 09d1cbf..2d419ee 100644
--- a/user_guide/database/transactions.html
+++ b/user_guide/database/transactions.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Transactions</title>
+<title>Transactions : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/utilities.html b/user_guide/database/utilities.html
index a40bfb8..f7e73e3 100644
--- a/user_guide/database/utilities.html
+++ b/user_guide/database/utilities.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Database Utility Class</title>
+<title>Database Utility Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/doc_style/index.html b/user_guide/doc_style/index.html
index c8c4667..832e6ab 100644
--- a/user_guide/doc_style/index.html
+++ b/user_guide/doc_style/index.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Writing Documentation</title>
+<title>Writing Documentation : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/alternative_php.html b/user_guide/general/alternative_php.html
index 61b9673..2f52b84 100644
--- a/user_guide/general/alternative_php.html
+++ b/user_guide/general/alternative_php.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Alternate PHP Syntax for View Files</title>
+<title>Alternate PHP Syntax for View Files : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/ancillary_classes.html b/user_guide/general/ancillary_classes.html
index 8ebab44..1a640e5 100644
--- a/user_guide/general/ancillary_classes.html
+++ b/user_guide/general/ancillary_classes.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Creating Ancillary Classes</title>
+<title>Creating Ancillary Classes : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/autoloader.html b/user_guide/general/autoloader.html
index 50d8fe9..7889b55 100644
--- a/user_guide/general/autoloader.html
+++ b/user_guide/general/autoloader.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Auto-loading Resources</title>
+<title>Auto-loading Resources : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/caching.html b/user_guide/general/caching.html
index b423326..cdb0260 100644
--- a/user_guide/general/caching.html
+++ b/user_guide/general/caching.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Web Page Caching</title>
+<title>Web Page Caching : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/controllers.html b/user_guide/general/controllers.html
index a05ee14..b561c8c 100644
--- a/user_guide/general/controllers.html
+++ b/user_guide/general/controllers.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Controllers</title>
+<title>Controllers : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/core_classes.html b/user_guide/general/core_classes.html
index 1e9cb1e..c8511fc 100644
--- a/user_guide/general/core_classes.html
+++ b/user_guide/general/core_classes.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Creating Core System Classes</title>
+<title>Creating Core System Classes : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/creating_libraries.html b/user_guide/general/creating_libraries.html
index d32dda9..77f4bed 100644
--- a/user_guide/general/creating_libraries.html
+++ b/user_guide/general/creating_libraries.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Creating Libraries</title>
+<title>Creating Libraries : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/credits.html b/user_guide/general/credits.html
index 7ad6b43..b4c53be 100644
--- a/user_guide/general/credits.html
+++ b/user_guide/general/credits.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Credits</title>
+<title>Credits : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/errors.html b/user_guide/general/errors.html
index 9c6a4e9..4c56bd3 100644
--- a/user_guide/general/errors.html
+++ b/user_guide/general/errors.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Error Handling</title>
+<title>Error Handling : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/helpers.html b/user_guide/general/helpers.html
index 6d443b9..86ec05b 100644
--- a/user_guide/general/helpers.html
+++ b/user_guide/general/helpers.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Helper Functions</title>
+<title>Helper Functions : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/hooks.html b/user_guide/general/hooks.html
index 11acc04..f5e94c9 100644
--- a/user_guide/general/hooks.html
+++ b/user_guide/general/hooks.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Hooks</title>
+<title>Hooks : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/index.html b/user_guide/general/index.html
index 999498d..fe84cc6 100644
--- a/user_guide/general/index.html
+++ b/user_guide/general/index.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Getting Started With CodeIgniter</title>
+<title>Getting Started With CodeIgniter : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/libraries.html b/user_guide/general/libraries.html
index c4c7a5f..3ff254b 100644
--- a/user_guide/general/libraries.html
+++ b/user_guide/general/libraries.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Using CodeIgniter Libraries</title>
+<title>Using CodeIgniter Libraries : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/managing_apps.html b/user_guide/general/managing_apps.html
index 0bce79f..9b07413 100644
--- a/user_guide/general/managing_apps.html
+++ b/user_guide/general/managing_apps.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Managing your Applications</title>
+<title>Managing your Applications : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/models.html b/user_guide/general/models.html
index 9564e55..3ecdf5e 100644
--- a/user_guide/general/models.html
+++ b/user_guide/general/models.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Models</title>
+<title>Models : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/plugins.html b/user_guide/general/plugins.html
index 449caae..41b1ea4 100644
--- a/user_guide/general/plugins.html
+++ b/user_guide/general/plugins.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Plugins</title>
+<title>Plugins : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/profiling.html b/user_guide/general/profiling.html
index c506874..c09fc8b 100644
--- a/user_guide/general/profiling.html
+++ b/user_guide/general/profiling.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Profiling Your Application</title>
+<title>Profiling Your Application : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/quick_reference.html b/user_guide/general/quick_reference.html
index 5c76cc4..941f771 100644
--- a/user_guide/general/quick_reference.html
+++ b/user_guide/general/quick_reference.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Quick Reference Chart</title>
+<title>Quick Reference Chart : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/requirements.html b/user_guide/general/requirements.html
index 54a03c4..82d5122 100644
--- a/user_guide/general/requirements.html
+++ b/user_guide/general/requirements.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Server Requirements</title>
+<title>Server Requirements : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/routing.html b/user_guide/general/routing.html
index d225c11..80798cb 100644
--- a/user_guide/general/routing.html
+++ b/user_guide/general/routing.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : URI Routing</title>
+<title>URI Routing : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/scaffolding.html b/user_guide/general/scaffolding.html
index 3c1385e..65c1544 100644
--- a/user_guide/general/scaffolding.html
+++ b/user_guide/general/scaffolding.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Scaffolding</title>
+<title>Scaffolding : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/security.html b/user_guide/general/security.html
index 271fea8..7e27263 100644
--- a/user_guide/general/security.html
+++ b/user_guide/general/security.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Security</title>
+<title>Security : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/urls.html b/user_guide/general/urls.html
index 823610f..96e9622 100644
--- a/user_guide/general/urls.html
+++ b/user_guide/general/urls.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : CodeIgniter URLs</title>
+<title>CodeIgniter URLs : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/views.html b/user_guide/general/views.html
index 41d6753..12a119a 100644
--- a/user_guide/general/views.html
+++ b/user_guide/general/views.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Views</title>
+<title>Views : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/array_helper.html b/user_guide/helpers/array_helper.html
index 0efcde2..6cdb3b2 100644
--- a/user_guide/helpers/array_helper.html
+++ b/user_guide/helpers/array_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Array Helper</title>
+<title>Array Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/cookie_helper.html b/user_guide/helpers/cookie_helper.html
index 93959ca..0e8447c 100644
--- a/user_guide/helpers/cookie_helper.html
+++ b/user_guide/helpers/cookie_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Cookie Helper</title>
+<title>Cookie Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/date_helper.html b/user_guide/helpers/date_helper.html
index 5389239..4f3f9b6 100644
--- a/user_guide/helpers/date_helper.html
+++ b/user_guide/helpers/date_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Date Helper</title>
+<title>Date Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/directory_helper.html b/user_guide/helpers/directory_helper.html
index 3ec990d..06b1d2a 100644
--- a/user_guide/helpers/directory_helper.html
+++ b/user_guide/helpers/directory_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Directory Helper</title>
+<title>Directory Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/download_helper.html b/user_guide/helpers/download_helper.html
index 3400459..1bfe163 100644
--- a/user_guide/helpers/download_helper.html
+++ b/user_guide/helpers/download_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Download Helper</title>
+<title>Download Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/email_helper.html b/user_guide/helpers/email_helper.html
index 7acee1d..36d6c10 100644
--- a/user_guide/helpers/email_helper.html
+++ b/user_guide/helpers/email_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Email Helper</title>
+<title>Email Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/file_helper.html b/user_guide/helpers/file_helper.html
index af724a9..ba24345 100644
--- a/user_guide/helpers/file_helper.html
+++ b/user_guide/helpers/file_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : File Helper</title>
+<title>File Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/form_helper.html b/user_guide/helpers/form_helper.html
index 1001929..446435e 100644
--- a/user_guide/helpers/form_helper.html
+++ b/user_guide/helpers/form_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Form Helper</title>
+<title>Form Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/html_helper.html b/user_guide/helpers/html_helper.html
index 14a404b..4e35963 100644
--- a/user_guide/helpers/html_helper.html
+++ b/user_guide/helpers/html_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : HTML Helper</title>
+<title>HTML Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/inflector_helper.html b/user_guide/helpers/inflector_helper.html
index a565176..00f88f1 100644
--- a/user_guide/helpers/inflector_helper.html
+++ b/user_guide/helpers/inflector_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Inflector Helper</title>
+<title>Inflector Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/path_helper.html b/user_guide/helpers/path_helper.html
index c406a04..0a0cdf4 100644
--- a/user_guide/helpers/path_helper.html
+++ b/user_guide/helpers/path_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Path Helper</title>
+<title>Path Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/security_helper.html b/user_guide/helpers/security_helper.html
index 576caa3..029606c 100644
--- a/user_guide/helpers/security_helper.html
+++ b/user_guide/helpers/security_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Security Helper</title>
+<title>Security Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/smiley_helper.html b/user_guide/helpers/smiley_helper.html
index 7829f46..b4f212e 100644
--- a/user_guide/helpers/smiley_helper.html
+++ b/user_guide/helpers/smiley_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Smiley Helper</title>
+<title>Smiley Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/string_helper.html b/user_guide/helpers/string_helper.html
index 489c6b3..238c48d 100644
--- a/user_guide/helpers/string_helper.html
+++ b/user_guide/helpers/string_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : String Helper</title>
+<title>String Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/text_helper.html b/user_guide/helpers/text_helper.html
index 5179949..d2ed6dc 100644
--- a/user_guide/helpers/text_helper.html
+++ b/user_guide/helpers/text_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Text Helper</title>
+<title>Text Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/typography_helper.html b/user_guide/helpers/typography_helper.html
index 7907134..eaeea4e 100644
--- a/user_guide/helpers/typography_helper.html
+++ b/user_guide/helpers/typography_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Typography Helper</title>
+<title>Typography Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/url_helper.html b/user_guide/helpers/url_helper.html
index 7bda86d..d8812e5 100644
--- a/user_guide/helpers/url_helper.html
+++ b/user_guide/helpers/url_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : URL Helper</title>
+<title>URL Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/xml_helper.html b/user_guide/helpers/xml_helper.html
index 4d9e220..b09484e 100644
--- a/user_guide/helpers/xml_helper.html
+++ b/user_guide/helpers/xml_helper.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : XML Helper</title>
+<title>XML Helper : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/index.html b/user_guide/index.html
index cba2b2f..e25eaee 100644
--- a/user_guide/index.html
+++ b/user_guide/index.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Welcome to CodeIgniter</title>
+<title>Welcome to CodeIgniter : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='userguide.css' />
diff --git a/user_guide/installation/downloads.html b/user_guide/installation/downloads.html
index 17e2209..436a90f 100644
--- a/user_guide/installation/downloads.html
+++ b/user_guide/installation/downloads.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Downloading CodeIgniter</title>
+<title>Downloading CodeIgniter : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/installation/index.html b/user_guide/installation/index.html
index e925c21..37675ed 100644
--- a/user_guide/installation/index.html
+++ b/user_guide/installation/index.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Installation Instructions</title>
+<title>Installation Instructions : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/installation/troubleshooting.html b/user_guide/installation/troubleshooting.html
index e3ea68c..cf90e54 100644
--- a/user_guide/installation/troubleshooting.html
+++ b/user_guide/installation/troubleshooting.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Troubleshooting</title>
+<title>Troubleshooting : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/installation/upgrade_154.html b/user_guide/installation/upgrade_154.html
index dcedce8..1294c87 100644
--- a/user_guide/installation/upgrade_154.html
+++ b/user_guide/installation/upgrade_154.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Upgrading from 1.5.3 to 1.5.4</title>
+<title>Upgrading from 1.5.3 to 1.5.4 : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/installation/upgrade_160.html b/user_guide/installation/upgrade_160.html
index bed3742..96ac77c 100644
--- a/user_guide/installation/upgrade_160.html
+++ b/user_guide/installation/upgrade_160.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Upgrading from 1.5.4 to 1.6.0</title>
+<title>Upgrading from 1.5.4 to 1.6.0 : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/installation/upgrade_161.html b/user_guide/installation/upgrade_161.html
index acbcc1e..ebee7ea 100644
--- a/user_guide/installation/upgrade_161.html
+++ b/user_guide/installation/upgrade_161.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Upgrading from 1.6.0 to 1.6.1</title>
+<title>Upgrading from 1.6.0 to 1.6.1 : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/installation/upgrade_162.html b/user_guide/installation/upgrade_162.html
index 66c498b..7da600a 100644
--- a/user_guide/installation/upgrade_162.html
+++ b/user_guide/installation/upgrade_162.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Upgrading from 1.6.1 to 1.6.2</title>
+<title>Upgrading from 1.6.1 to 1.6.2 : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/installation/upgrading.html b/user_guide/installation/upgrading.html
index d778298..ee11468 100644
--- a/user_guide/installation/upgrading.html
+++ b/user_guide/installation/upgrading.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Upgrading From a Previous Version</title>
+<title>Upgrading From a Previous Version : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/benchmark.html b/user_guide/libraries/benchmark.html
index 177bbc7..14d33e5 100644
--- a/user_guide/libraries/benchmark.html
+++ b/user_guide/libraries/benchmark.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Benchmarking Class</title>
+<title>Benchmarking Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/calendar.html b/user_guide/libraries/calendar.html
index c1d237b..0cdb395 100644
--- a/user_guide/libraries/calendar.html
+++ b/user_guide/libraries/calendar.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Calendaring Class</title>
+<title>Calendaring Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/config.html b/user_guide/libraries/config.html
index b67c93a..23e851d 100644
--- a/user_guide/libraries/config.html
+++ b/user_guide/libraries/config.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Config Class</title>
+<title>Config Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/email.html b/user_guide/libraries/email.html
index fb784a7..8f1b149 100644
--- a/user_guide/libraries/email.html
+++ b/user_guide/libraries/email.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Email Class</title>
+<title>Email Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/encryption.html b/user_guide/libraries/encryption.html
index 913b7b1..cc3028b 100644
--- a/user_guide/libraries/encryption.html
+++ b/user_guide/libraries/encryption.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Encryption Class</title>
+<title>Encryption Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/file_uploading.html b/user_guide/libraries/file_uploading.html
index 9aa4f71..4ab093e 100644
--- a/user_guide/libraries/file_uploading.html
+++ b/user_guide/libraries/file_uploading.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : File Uploading Class</title>
+<title>File Uploading Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/ftp.html b/user_guide/libraries/ftp.html
index 0e577e9..7111a27 100644
--- a/user_guide/libraries/ftp.html
+++ b/user_guide/libraries/ftp.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : FTP Class</title>
+<title>FTP Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/image_lib.html b/user_guide/libraries/image_lib.html
index 028414b..9eac11c 100644
--- a/user_guide/libraries/image_lib.html
+++ b/user_guide/libraries/image_lib.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Image Manipulation Class</title>
+<title>Image Manipulation Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/input.html b/user_guide/libraries/input.html
index 0b583a0..f46c8b4 100644
--- a/user_guide/libraries/input.html
+++ b/user_guide/libraries/input.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Input Class</title>
+<title>Input Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/language.html b/user_guide/libraries/language.html
index dc5c28c..e5652c6 100644
--- a/user_guide/libraries/language.html
+++ b/user_guide/libraries/language.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Language Class</title>
+<title>Language Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/loader.html b/user_guide/libraries/loader.html
index 04e4966..466e45c 100644
--- a/user_guide/libraries/loader.html
+++ b/user_guide/libraries/loader.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Loader Class</title>
+<title>Loader Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
@@ -139,7 +139,7 @@
 it will instead return the data as a string.</p>
 
 
-<h2>$this->load->language('<var>file_name</var>')</h2>
+<h2>$this->load->lang('<var>file_name</var>')</h2>
 <p>This function is an alias of the <a href="language.html">language loading function</a>: $this->lang->load()</p>
 
 <h2>$this->load->config('<var>file_name</var>')</h2>
diff --git a/user_guide/libraries/output.html b/user_guide/libraries/output.html
index 69ab2f1..7b9082e 100644
--- a/user_guide/libraries/output.html
+++ b/user_guide/libraries/output.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Output Class</title>
+<title>Output Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/pagination.html b/user_guide/libraries/pagination.html
index 072cdd7..67c96da 100644
--- a/user_guide/libraries/pagination.html
+++ b/user_guide/libraries/pagination.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Pagination Class</title>
+<title>Pagination Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/parser.html b/user_guide/libraries/parser.html
index d72891a..b0fc35f 100644
--- a/user_guide/libraries/parser.html
+++ b/user_guide/libraries/parser.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Template Parser Class</title>
+<title>Template Parser Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/sessions.html b/user_guide/libraries/sessions.html
index 69cc6ba..c052463 100644
--- a/user_guide/libraries/sessions.html
+++ b/user_guide/libraries/sessions.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Session Class</title>
+<title>Session Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/table.html b/user_guide/libraries/table.html
index 5af1fd0..3929348 100644
--- a/user_guide/libraries/table.html
+++ b/user_guide/libraries/table.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : HTML Table Class</title>
+<title>HTML Table Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/trackback.html b/user_guide/libraries/trackback.html
index 6ca1fec..767837f 100644
--- a/user_guide/libraries/trackback.html
+++ b/user_guide/libraries/trackback.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Trackback Class</title>
+<title>Trackback Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/unit_testing.html b/user_guide/libraries/unit_testing.html
index 5e67202..86182dd 100644
--- a/user_guide/libraries/unit_testing.html
+++ b/user_guide/libraries/unit_testing.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Unit Testing Class</title>
+<title>Unit Testing Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/uri.html b/user_guide/libraries/uri.html
index d53ebe3..e683e86 100644
--- a/user_guide/libraries/uri.html
+++ b/user_guide/libraries/uri.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : URI Class</title>
+<title>URI Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/user_agent.html b/user_guide/libraries/user_agent.html
index 620b1d9..1354daa 100644
--- a/user_guide/libraries/user_agent.html
+++ b/user_guide/libraries/user_agent.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : User Agent Class</title>
+<title>User Agent Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/validation.html b/user_guide/libraries/validation.html
index e539fbf..01bf60b 100644
--- a/user_guide/libraries/validation.html
+++ b/user_guide/libraries/validation.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Form Validation</title>
+<title>Form Validation : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/xmlrpc.html b/user_guide/libraries/xmlrpc.html
index 2f366be..cd4a04a 100644
--- a/user_guide/libraries/xmlrpc.html
+++ b/user_guide/libraries/xmlrpc.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : XML-RPC and XML-RPC Server Classes</title>
+<title>XML-RPC and XML-RPC Server Classes : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/zip.html b/user_guide/libraries/zip.html
index 7ee4d7b..5aeb1da 100644
--- a/user_guide/libraries/zip.html
+++ b/user_guide/libraries/zip.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Zip Encoding Class</title>
+<title>Zip Encoding Class : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/license.html b/user_guide/license.html
index 042605e..db0c766 100644
--- a/user_guide/license.html
+++ b/user_guide/license.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : CodeIgniter License Agreement</title>
+<title>CodeIgniter License Agreement : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='userguide.css' />
diff --git a/user_guide/overview/appflow.html b/user_guide/overview/appflow.html
index 8e1d606..f1a2ee5 100644
--- a/user_guide/overview/appflow.html
+++ b/user_guide/overview/appflow.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Application Flow Chart</title>
+<title>Application Flow Chart : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/overview/at_a_glance.html b/user_guide/overview/at_a_glance.html
index 6dfba8f..1da6233 100644
--- a/user_guide/overview/at_a_glance.html
+++ b/user_guide/overview/at_a_glance.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : CodeIgniter at a Glance</title>
+<title>CodeIgniter at a Glance : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/overview/features.html b/user_guide/overview/features.html
index 99e18fb..c15f45f 100644
--- a/user_guide/overview/features.html
+++ b/user_guide/overview/features.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : CodeIgniter Features</title>
+<title>CodeIgniter Features : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/overview/goals.html b/user_guide/overview/goals.html
index a338dcc..72e7a4f 100644
--- a/user_guide/overview/goals.html
+++ b/user_guide/overview/goals.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Design and Architectural Goals</title>
+<title>Design and Architectural Goals : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/overview/index.html b/user_guide/overview/index.html
index 8974061..49844ed 100644
--- a/user_guide/overview/index.html
+++ b/user_guide/overview/index.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : CodeIgniter Overview</title>
+<title>CodeIgniter Overview : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/overview/mvc.html b/user_guide/overview/mvc.html
index b3a79c3..1b3f30c 100644
--- a/user_guide/overview/mvc.html
+++ b/user_guide/overview/mvc.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Model-View-Controller</title>
+<title>Model-View-Controller : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/toc.html b/user_guide/toc.html
index e5d5879..6a1813a 100644
--- a/user_guide/toc.html
+++ b/user_guide/toc.html
@@ -2,7 +2,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
-<title>CodeIgniter User Guide : Table of Contents</title>
+<title>Table of Contents : CodeIgniter User Guide</title>
 
 <style type='text/css' media='all'>@import url('userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='userguide.css' />
